﻿const router = require('express').Router();
const joi = require('joi');
const joiValidate = require('../../utils/joiValidate');
const courseService = require('../../service/course/courseService');
const LockUtil = require('../../utils/lockUtil');
const ErrorCode = require('../../utils/errorCode');
const verifyUser = require('../../utils/jwtHanlder');

/**
 * @apiDefine Course  课程相关的接口
 */

/**
 * @api {post} /v1/course/add  添加课程
 * @apiVersion 1.0.0
 * @apiName CourseAdd
 * @apiGroup  Course
 *
 * @apiDescription 添加团课，训练营和私教等课程
 *
 * @apiParam {Number=1,2,3} type  (课程类型，1：团课，2：私教，3：训练营)
 * @apiParam {Object} bigCourse  团课（当课程类型为1的时候，必传）
 * @apiParam {String} bigCourse.courseName  团课名称
 * @apiParam {Number} bigCourse.classTime  课长时间（分钟）
 * @apiParam {Number} bigCourse.maxNum  最大报名人数
 * @apiParam {Number} bigCourse.totalMoney  团课总金额
 * @apiParam {Number} bigCourse.peopleNum  团课开课总人数
 * @apiParam {String} bigCourse.storeName  团课门店地址
 * @apiParam {String} bigCourse.label  分类标签
 * @apiParam {String} bigCourse.startTime  开始时间
 * @apiParam {String} bigCourse.signEndTime  报名截止时间
 * @apiParam {String} bigCourse.description  团课描述
 * @apiParam {Object} bigCourse.addressInfo  地址信息
 * @apiParam {string} bigCourse.addressInfo.provinceId  省Id
 * @apiParam {string} bigCourse.addressInfo.cityId  城市Id
 * @apiParam {string} bigCourse.addressInfo.areaId  区域Id
 * @apiParam {string} bigCourse.addressInfo.lat  维度
 * @apiParam {string} bigCourse.addressInfo.lon  精度
 * @apiParam {Array} bigCourse.images  团课图片内容(数组)
 * @apiParam {Object} selfCourse  私教课（当课程类型为2的时候，必传）
 * @apiParam {String} selfCourse.courseName  私教课名称
 * @apiParam {Number} selfCourse.totalMoney  私教课总价格
 * @apiParam {String} selfCourse.storeName  私教课门店信息
 * @apiParam {String} selfCourse.description  私教课描述
 * @apiParam {String} selfCourse.signEndTime  报名截止时间
 * @apiParam {Number} selfCourse.isSend  是否推送
 * @apiParam {Array} selfCourse.images  私教课图片信息
 * @apiParam {Object} selfCourse.addressInfo  地址信息
 * @apiParam {string} selfCourse.addressInfo.provinceId  省Id
 * @apiParam {string} selfCourse.addressInfo.cityId  城市Id
 * @apiParam {string} selfCourse.addressInfo.areaId  区域Id
 * @apiParam {string} selfCourse.addressInfo.lat  维度
 * @apiParam {string} selfCourse.addressInfo.lon
 * @apiParam {Object} camp  训练营（当课程类型为3时，必传）
 * @apiParam {String} camp.courseName  课程名称
 * @apiParam {Number} camp.totalMoney  课程总价格
 * @apiParam {Number} camp.peopleNum  训练营总人数
 * @apiParam {Number} camp.label  标签
 * @apiParam {Number} camp.maxNum  最大报名人数
 * @apiParam {String} camp.description  训练营描述
 * @apiParam {String} camp.signEndTime  报名截止时间
 * @apiParam {Object} camp.addressInfo  地址信息
 * @apiParam {string} camp.addressInfo.provinceId  省Id
 * @apiParam {string} camp.addressInfo.cityId  城市Id
 * @apiParam {string} camp.addressInfo.areaId  区域Id
 * @apiParam {string} camp.addressInfo.lat  维度
 * @apiParam {string} camp.addressInfo.lon
 * @apiParam {Array} camp.images  训练营相关图片介绍
 * @apiParam {Object[]} camp.details  训练营课时详情
 * @apiParam {String} camp.details.className  训练营课时名称
 * @apiParam {String} camp.details.storeName  训练营课时位置
 * @apiParam {String} camp.details.classStartTime  训练营开课时间
 *
 * @apiExample Example usage:
 * curl -i http://localhost:3502/v1/course/add
 *
 * @apiSuccess {Number} code      请求结果编码，0：正常， 其他为异常
 * @apiSuccess {string} message    请求结果编码对应的message
 *
 * @apiSuccessExample 正常响应：
 *     HTTP/1.1 200
 *     {
          "code": 200,
          "message": "请求成功"
       }
 *
 *
 * @apiError  ServerError  服务器异常
 *
 * @apiErrorExample Response (example):
 *     HTTP/1.1 500 ServerError
 *     {
 *       "code": 500,
 *       "message": "服务器异常"
 *     }
 */
router.post('/add', verifyUser.verify(), joiValidate(joi.object().keys({
  type: joi.number().valid([1,2,3]).required().label('请选择课程类型'),
  bigCourse: joi.when('type', { is: 1, then: joi.object({
      courseName: joi.string().max(32).required().label('请传入团课名称，32个字符限制'),
      classTime: joi.number().required().label('请传入课时时间（分钟'),
      totalMoney: joi.number().min(1).required().label('请传入总价,不能低于1块'),
      peopleNum: joi.number().required().label('请传入参加总人数'),
      storeName: joi.string().required().label('请传入门店名称'),
      label: joi.string().max(32).label('请传入标签名称'),
      description: joi.string().required().label('请传入描述信息'),
      startTime: joi.string().required().label('请选择开始时间'),
      signEndTime: joi.string().isoDate().required().label('请传入报名截止时间'),
      images: joi.array().items(joi.string()).min(1).required().label('请传入图片介绍'),
      maxNum: joi.number().label('请传入最大报名人数'),
      addressInfo: joi.object({
        provinceId: joi.string().label('请传入省市Id'),
        cityId: joi.string().label('请传入城市Id'),
        areaId: joi.string().label('请传入区域Id'),
        lat: joi.string().label('请传入维度'),
        lon: joi.string().label('请传入精度'),
      })
    }).required().label('请完善团课信息')}),
  selfCourse: joi.when('type', { is: 2, then: joi.object({
      courseName: joi.string().required().max(32).label('请传入私教课标题,32个字符限制'),
      totalMoney: joi.number().min(1).required().label('请传入总价,不能低于1块'),
      storeName: joi.string().required().label('请传入门店信息'),
      description: joi.string().required().label('请传入描述信息'),
      isSend: joi.number().valid([0, 1]).label('是否推送'),
      signEndTime: joi.string().required().label('请传入报名截止时间'),
      // startTime: joi.string().required().label(), todo 加上这个开始时间
      images: joi.array().items(joi.string()).min(1).required().label('请传入图片介绍'),
      addressInfo: joi.object({
        provinceId: joi.string().label('请传入省市Id'),
        cityId: joi.string().label('请传入城市Id'),
        areaId: joi.string().label('请传入区域Id'),
        lat: joi.string().label('请传入维度'),
        lon: joi.string().label('请传入精度'),
      })
    }).required().label('请完善私教信息')}),
  camp: joi.when('type', { is: 3, then: joi.object({
      courseName: joi.string().max(32).required().label('请传入训练营课标题，32个字符限制'),
      totalMoney: joi.number().min(1).required().label('请传入总价,不能低于1块'),
      peopleNum: joi.number().required().label('请传入训练营总人数'),
      description: joi.string().required().label('请传入描述信息'),
      label: joi.string().max(32).label('请传入标签名称'),
      signEndTime: joi.string().label('请传入报名截止时间'),
      maxNum: joi.number().label('请传入最大报名人数'),
      // startTime: joi.string().required().label(), todo 加上这个开始时间
      images: joi.array().items(joi.string()).min(1).required().label('请传入图片介绍'),
      details: joi.array().items(joi.object({
        className: joi.string().required().label('请传入课时名称'),
        storeName: joi.string().required().label('请传入课时位置'),
        classStartTime: joi.string().isoDate().required().label('请传入开课时间')
      })).min(1).required('请完善课时的相关信息'),
      addressInfo: joi.object({
        provinceId: joi.string().label('请传入省市Id'),
        cityId: joi.string().label('请传入城市Id'),
        areaId: joi.string().label('请传入区域Id')
      })
    }).required().label('请完善私教相关信息') })
})), (req, res, next) => {
  const { userId } = req.user;
  const { bigCourse, type, selfCourse, camp} = req.body;
  // 创建申请创建锁，避免重复提交
  const lockUtil = new LockUtil(`course:add:${type}:`, userId, 120);
  return lockUtil.tryLock()
    .then(() => courseService.add({ userId, bigCourse, type, selfCourse, camp }))
    .then((data) => {
      // 删除请求锁9
      lockUtil.unlock().catch(console.error);
      res.success({ id: data });
    })
    .catch((err) => {
      // 非频繁访问时删除频繁队列key
      if (err.code !== ErrorCode.FREQUENT_REQUEST) lockUtil.unlock().catch(console.error);
      next(err);
    });
});

/**
 * @api {get} /v1/course/list  获取课程列表
 * @apiVersion 1.0.0
 * @apiName CourseList
 * @apiGroup  Course
 *
 * @apiDescription 获取课程列表 （获取所有的课程列表）
 *
 * @apiParam {Number=0,1,2,3} [type]  类别（0代表全部，1代表团课，2代表私教，3代表训练营）
 * @apiParam {Number} [offset]  分页参数
 * @apiParam {Number} [limit]  分页参数
 * @apiParam {string} [q]  搜索条件
 * @apiParam {string} [provinceId]  省或者自治区Id
 * @apiParam {string} [cityId]  城市Id
 * @apiParam {string} [areaId]  区域Id
 * @apiParam {string} [time]  查询时间
 *
 * @apiExample Example usage:
 * curl -i http://localhost:3502/v1/course/list
 *
 * @apiSuccess {Number} code      请求结果编码，0：正常， 其他为异常
 * @apiSuccess {string} message    请求结果编码对应的message
 * @apiSuccess {Object} data    结果集对象
 * @apiSuccess {Object} data.list    结果集对象
 * @apiSuccess {Number} data.list.type    类别(课程类别)
 * @apiSuccess {Number} data.list.id    课程Id
 * @apiSuccess {String} data.list.courseName    课程名称
 * @apiSuccess {Number} data.list.classNum    课时节数
 * @apiSuccess {String} data.list.startTime    开始时间
 * @apiSuccess {Number} data.list.classTime    课程时间
 * @apiSuccess {Number} data.list.totalMoney    金额
 * @apiSuccess {Number} data.list.peopleNum    人数
 * @apiSuccess {String} data.list.label    标签
 * @apiSuccess {String} data.list.description    描述
 * @apiSuccess {Object} data.list.images    图片(数组，所有的图片，可以取第一条，需要判断下第一条是否有)
 * @apiSuccess {String} data.list.images.imagePath   图片路劲
 *
 * @apiSuccessExample 正常响应：
 *     HTTP/1.1 200
 *     {
          "code": 200,
          "message": "请求成功"
          "data": {
            "list": [
                {
                    "type": 1,
                    "id": 1,
                    "courseName": "xxx",
                    "classNum": 12,
                    "startTime": "2019-06-08 17:07:04",
                    "classTime": 32,
                    "totalMoney": "12.00",
                    "peopleNum": 3,
                    "label": "xxx",
                    "storeName": "xx",
                    "description": "fds",
                    "JUserId": 8,
                    "images": [
                        {
                            "courseId": 1,
                            "imagePath": "http://xiaoqingjing.oss-cn-beijing.aliyuncs.com/tyk/wxcbbe76597beeacf1.o6zAJs4-ejA5oZd4Y8LttNODu5Go.OC4tW5NgmWfe5cb23895f97d7edbc59937059b0740e2.jpg"
                        }
                    ]
                }
            ],
            "count": 1
            }
       }
 *
 *
 * @apiError  ServerError  服务器异常
 *
 * @apiErrorExample Response (example):
 *     HTTP/1.1 500 ServerError
 *     {
 *       "code": 500,
 *       "message": "服务器异常"
 *     }
 */
router.get('/list',  joiValidate(joi.object().keys({
  type: joi.number().valid([0,1,2,3]).label('请选择课程类别'),
  offset: joi.number().label('请传入分页参数'),
  limit: joi.number().label('请传入分页参数'),
  q: joi.string().label('查找条件'),
  time: joi.string().allow('', null).label('请输入时间查询'),
  provinceId: joi.string().allow('', null).label('请传入省市Id'),
  cityId: joi.string().allow('', null).label('请传入城市Id'),
  areaId: joi.string().allow('', null).label('请传入区域Id'),
})), (req, res, next) => {
    const { type, q, provinceId, cityId, areaId, time } = req.query;
    let { offset, limit } = req.query;
    offset = offset && Number(offset) || 0;
    limit = limit && Number(limit) || 20;
    courseService.list({ type, offset, limit, q, provinceId, cityId, areaId, time })
        .then((data) => res.success(data))
        .catch(e => next(e))
});

/**
 * @api {get} /v1/course/detail  获取课程详情
 * @apiVersion 1.0.0
 * @apiName CourseDetail
 * @apiGroup  Course
 *
 * @apiDescription 获取课程详情 （获取所有的课程列表）
 *
 * @apiParam {Number} courseId  课程Id
 *
 * @apiExample Example usage:
 * curl -i http://localhost:3502/v1/course/detail
 *
 * @apiSuccess {Number} code      请求结果编码，0：正常， 其他为异常
 * @apiSuccess {string} message    请求结果编码对应的message
 * @apiSuccess {Object} data    结果集对象
 * @apiSuccess {Object} data.detail    结果集对象
 * @apiSuccess {Number} data.detail.type    类别(课程类别)
 * @apiSuccess {Number} data.detail.id    课程Id
 * @apiSuccess {String} data.detail.courseName    课程名称
 * @apiSuccess {Number} data.detail.classNum    课时节数
 * @apiSuccess {String} data.detail.startTime    开始时间
 * @apiSuccess {Number} data.detail.classTime    课程时间
 * @apiSuccess {Number} data.detail.totalMoney    金额
 * @apiSuccess {Number} data.detail.peopleNum    人数
 * @apiSuccess {String} data.detail.label    标签
 * @apiSuccess {String} data.detail.lon    精度
 * @apiSuccess {String} data.detail.provinceId    省Id
 * @apiSuccess {String} data.detail.cityId    城市Id
 * @apiSuccess {String} data.detail.areaId    区域Id
 * @apiSuccess {String} data.detail.lat    维度
 * @apiSuccess {String} data.detail.description    描述
 * @apiSuccess {Number} data.detail.isSend    1代表是那种分享出去的课程
 * @apiSuccess {Object} data.detail.images    图片(数组，所有的图片，可以取第一条，需要判断下第一条是否有)
 * @apiSuccess {String} data.detail.images.imagePath   图片路劲
 * @apiSuccess {Object} data.detail.userInfo 用户信息集合
 * @apiSuccess {String} data.detail.userInfo.name 用户名称
 * @apiSuccess {String} data.detail.userInfo.avatar 用户头像
 * @apiSuccess {Number} data.detail.belongsToJiao 是否属于教练(1代表是，0代表不是)
 * @apiSuccess {Number} data.detail.isBuy 是否被购买（1代表已经购买，0没有被购买）主要针对私教
 * @apiSuccess {Number} data.detail.hasBuy 是否购买（1代表购买，0没有购买）
 * @apiSuccess {Number} data.detail.canBuy 是否可以购买，即是否可以预约（1代表可以购买，0代表不能购买）
 * @apiSuccess {Number} data.detail.canCancel 是否可以取消（1代表可以取消，0代表不能取消） (用户和教练都是这个字段)
 * @apiSuccess {Number} data.detail.sellteStatus 当前课程状态(0代表课程未开始，1代表课程已经开始但是未销课，10代表已销课)
 * @apiSuccess {Object} data.detail.details
 * @apiSuccess {String} data.detail.details.className 课时名称
 * @apiSuccess {String} data.detail.details.startTime 开始时间
 * @apiSuccess {String} data.detail.details.storeName 开课地址
 * @apiSuccess {Number} data.detail.details.sellteStatus 当前课时状态(0代表课程未开始，1代表课程已经开始但是未销课，10代表已销课)
 * @apiSuccess {Number} data.detail.details.canSub (1可预约，0代表不可预约)
 * @apiSuccess {Number} data.detail.details.hasSub (1代表已预约，0代表未预约)
 *
 * @apiSuccessExample 正常响应：
 *     HTTP/1.1 200
     {
        "code": 200,
        "message": "请求成功",
        "data": {
            "detail": {
                "type": 3,
                "id": 5,
                "courseName": "私教课11111",
                "classNum": 0,
                "startTime": "2019-06-19 17:29:10",
                "classTime": 0,
                "totalMoney": "12.00",
                "peopleNum": 1,
                "label": "xafd",
                "storeName": "",
                "description": "我的",
                "JUserId": 25,
                "cStatus": 1,
                "images": [
                    {
                        "courseId": 5,
                        "imagePath": "sdsfsd"
                    }
                ],
                "userInfo": {
                    "name": "",
                    "avatar": ""
                },
                "details": [
                    {
                        "className": "ss",
                        "startTime": "2019-12-12 08:00:00",
                        "storeName": "dfas",
                        "id": 4,
                        "sellteStatus": 10,
                        "canSub": 0,
                        "hasSub": 1
                    }
                ],
                "belongsToJiao": 1,
                "hasBuy": 0,
                "canBuy": 0,
                "canCancel": 1,
                "sellteStatus": 0,
                "canSub": 0,
                "lat": "",
                "lon": "",
                "provinceId": "",
                "cityId": "",
                "areaId": ""
            }
        }
    }
 *
 *
 * @apiError  ServerError  服务器异常_
 *
 * @apiErrorExample Response (example):
 *     HTTP/1.1 500 ServerError
 *     {
 *       "code": 500,
 *       "message": "服务器异常"
 *     }
 */
router.get('/detail',  verifyUser.verifyHasToken(), joiValidate(joi.object().keys({
    courseId: joi.number().required().label('请传入课程Id')
})), (req, res, next) => {
    const { courseId } = req.query;
    const { userId } = req.user;
    courseService.getDetail({ courseId, userId })
        .then((data) => res.success({ detail: data }))
        .catch(e => next(e))
});

/**
 * @api {post} /v1/course/sellte  结算课程
 * @apiVersion 1.0.0
 * @apiName CourseSellte
 * @apiGroup  Course
 *
 * @apiDescription 结算课程 (结算课程)
 *
 * @apiParam {Number} courseId  课程Id
 * @apiParam {Number} [campId]  课时Id 如果是训练营的那种销课就必须了
 * @apiParam {Array} [images]  图片数组
 * @apiParam {String} [description]  销课内容
 * @apiParam {Array} [users]  用户Id数组
 *
 * @apiExample Example usage:
 * curl -i http://localhost:3502/v1/course/sellte
 *
 * @apiSuccess {Number} code      请求结果编码，0：正常， 其他为异常
 * @apiSuccess {string} message    请求结果编码对应的message
 *
 * @apiSuccessExample 正常响应：
 *     HTTP/1.1 200
 *     {
          "code": 200,
          "message": "请求成功"
       }
 *
 *
 * @apiError  ServerError  服务器异常
 *
 * @apiErrorExample Response (example):
 *     HTTP/1.1 500 ServerError
 *     {
 *       "code": 500,
 *       "message": "服务器异常"
 *     }
 */
router.post('/sellte', verifyUser.verify(), joiValidate(joi.object().keys({
  courseId: joi.number().required().label('请传入课程Id'),
  campId: joi.number().label('请传入课时Id'),
  users: joi.array().label('请传入销课用户'),
  images: joi.array().label('请传入销课的图片信息'),
  description: joi.string().label('请传入描述信息'),
})), (req, res, next) => {
  const { userId } = req.user;
  const { courseId, campId } = req.body;
  let { users, images, description } = req.body;
  users = users || [];
  images = images || [];
  description = description || '';

  // 创建申请创建锁，避免重复提交
  const lockUtil = new LockUtil(`course:settle:`, courseId, 120);
  return lockUtil.tryLock()
    .then(() => courseService.sellte({ userId, courseId, campId, users, images, description }))
    .then((data) => {
      // 删除请求锁
      lockUtil.unlock().catch(console.error);
      res.success(data);
    })
    .catch((err) => {
      // 非频繁访问时删除频繁队列key
      if (err.code !== ErrorCode.FREQUENT_REQUEST) lockUtil.unlock().catch(console.error);
      next(err);
    });
});

/**
 * @api {get} /v1/course/userlist  获取课程的用户列表
 * @apiVersion 1.0.0
 * @apiName CourseUserList
 * @apiGroup  Course
 *
 * @apiDescription 获取课程的用户列表
 *
 * @apiParam {Number} courseId  课程Id
 * @apiParam {Number} [campId]  课时Id
 *
 * @apiExample Example usage:
 * curl -i http://localhost:3502/v1/course/userlist
 *
 * @apiSuccess {Number} code      请求结果编码，0：正常， 其他为异常
 * @apiSuccess {string} message    请求结果编码对应的message
 * @apiSuccess {Object} data    结果集对象
 * @apiSuccess {Number} data.list.jUserId    用户Id
 * @apiSuccess {Number} data.list.status    （1代表待预约，5代表已预约，10代表已销课）
 * @apiSuccess {Number} data.list.courseId    课程Id
 * @apiSuccess {Number} data.list.isJoin    (1代表已加入，0代表未加入)
 * @apiSuccess {String} data.list.userName    用户昵称
 *
 * @apiSuccessExample 正常响应：
 *     HTTP/1.1 200
 {
    "code": 200,
    "message": "请求成功",
    "data": {
              "list": [
          {
                "jUserId": 1,
                "status": 1,
                "courseId": 7,
                "isJoin": 0,
                "userName": "文坦",
                "avatar": "https://wx.qlogo.cn/mmopen/vi_32/YQ4EFj8Rx4Vgx3a2peeGpiaxn7RKqo56ZyUNltnppGKgB8v2EZTlmmb4ohR2toJYsfrHZlhpWDeRzaM9N2XsZ9w/132"
            }
        ]
    }
}
 *
 * @apiError  ServerError  服务器异常
 *
 * @apiErrorExample Response (example):
 *     HTTP/1.1 500 ServerError
 *     {
 *       "code": 500,
 *       "message": "服务器异常"
 *     }
 */
router.get('/userlist', verifyUser.verify(), joiValidate(joi.object().keys({
  courseId: joi.number().required().label('请传入课程Id'),
  campId: joi.number().allow('', null).label('请传入课时Id')
})),(req, res, next) => {
  const { courseId, campId } = req.query;
  // const { userId } = req.user;
  courseService.getUserList({ courseId, campId })
    .then(data => res.success(data))
    .catch(e => next(e))
});

/**
 * @api {post} /v1/course/camp/add  添加课时
 * @apiVersion 1.0.0
 * @apiName CourseCampAdd
 * @apiGroup  Course
 *
 * @apiDescription 添加课时 (添加课时)
 *
 * @apiParam {Number} courseId  课程Id
 * @apiParam {Object[]} details
 * @apiParam {String} details.className 课时名称
 * @apiParam {String} details.storeName 开课地址
 * @apiParam {String} details.classStartTime 开课时间
 *
 * @apiExample Example usage:
 * curl -i http://localhost:3502/v1/course/sellte
 *
 * @apiSuccess {Number} code      请求结果编码，0：正常， 其他为异常
 * @apiSuccess {string} message    请求结果编码对应的message
 *
 * @apiSuccessExample 正常响应：
 *     HTTP/1.1 200
 *     {
          "code": 200,
          "message": "请求成功"
       }
 *
 *
 * @apiError  ServerError  服务器异常
 *
 * @apiErrorExample Response (example):
 *     HTTP/1.1 500 ServerError
 *     {
 *       "code": 500,
 *       "message": "服务器异常"
 *     }
 */
router.post('/camp/add', verifyUser.verify(), joiValidate(joi.object().keys({
  courseId: joi.number().required().label('请传入课程Id'),
    details: joi.array().items(joi.object({
        className: joi.string().required().label('请传入课时名称'),
        storeName: joi.string().required().label('请传入课时位置'),
        classStartTime: joi.string().isoDate().required().label('请传入开课时间')
    })).min(1).required('请完善课时的相关信息')
})), (req, res, next) => {
  const { userId } = req.user;
  const { courseId, details} = req.body;
  courseService.addCamp({ courseId, details, userId })
    .then(data => res.success(data))
    .catch(e => next(e))
});

/**
 * @api {get} /v1/course/jlist  获取教练列表
 * @apiVersion 1.0.0
 * @apiName CourseJUSERList
 * @apiGroup  Course
 *
 * @apiDescription 获取教练列表
 *
 * @apiParam {Number} [offset]  分页参数
 * @apiParam {Number} [limit]  分页参数
 *
 * @apiExample Example usage:
 * curl -i http://localhost:3502/v1/course/jlist
 *
 * @apiSuccess {Number} code      请求结果编码，0：正常， 其他为异常
 * @apiSuccess {string} message    请求结果编码对应的message
 * @apiSuccess {Object} data    结果集对象
 * @apiSuccess {Object} data.list    结果集对象
 * @apiSuccess {Number} data.list.type    类别(课程类别)
 * @apiSuccess {Number} data.list.id    课程Id
 * @apiSuccess {String} data.list.avatar    课程名称
 * @apiSuccess {String} data.list.name    名字
 * @apiSuccess {String} data.list.description    描述
 * @apiSuccess {Number} data.count    数量
 *
 * @apiSuccessExample 正常响应：
 *     HTTP/1.1 200
 {
    "code": 200,
    "message": "请求成功",
    "data": {
        "list": [
            {
                "id": 2,
                "avatar": "https://wx.qlogo.cn/mmopen/vi_32/Q0j4TwGTfTLqWZtaIAIyPAf2ldxduBWVNtCAoahcGRAWvZDz1rkTNFUmUeYFkaFv2WiaSveTjbHwX5OzgiaVB87Q/132",
                "name": "胡",
                "description": "12"
            }
        ],
        "count": 1
    }
}
 *
 *
 * @apiError  ServerError  服务器异常
 *
 * @apiErrorExample Response (example):
 *     HTTP/1.1 500 ServerError
 *     {
 *       "code": 500,
 *       "message": "服务器异常"
 *     }
 */
router.get('/jlist', verifyUser.verifyHasToken(), joiValidate(joi.object().keys({
  offset: joi.number().label('请传入分页参数'),
  limit: joi.number().label('请传入分页参数'),
})), (req, res, next) => {
  let { offset, limit } = req.query;
    offset = offset && Number(offset) || 0;
    limit = limit && Number(limit) || 20;
  courseService.getCourseUserList({ offset, limit })
    .then(data => res.success(data))
    .catch(e => next(e))
});

/**
 * @api {post} /v1/course/modify  修改课程信息
 * @apiVersion 1.0.0
 * @apiName CourseModify
 * @apiGroup  Course
 *
 * @apiDescription 修改课程信息
 * @apiParam {Number} courseId  课程Id (下面的参数和创建课程一样，组装成一起的给我)
 * @apiParam {Object} bigCourse  团课（当课程类型为1的时候，必传）
 * @apiParam {String} bigCourse.courseName  团课名称
 * @apiParam {Number} bigCourse.classTime  课长时间（分钟）
 * @apiParam {Number} bigCourse.peopleNum  团课开课总人数
 * @apiParam {String} bigCourse.storeName  团课门店地址
 * @apiParam {String} bigCourse.label  分类标签
 * @apiParam {String} bigCourse.startTime  开始时间
 * @apiParam {String} bigCourse.description  团课描述
 * @apiParam {Array} bigCourse.images  团课图片内容(数组)
 * @apiParam {Object} bigCourse.addressInfo  地址信息
 * @apiParam {string} bigCourse.addressInfo.provinceId  省Id
 * @apiParam {string} bigCourse.addressInfo.cityId  城市Id
 * @apiParam {string} bigCourse.addressInfo.areaId  区域Id
 * @apiParam {string} bigCourse.addressInfo.lat  维度
 * @apiParam {string} bigCourse.addressInfo.lon  精度
 * @apiParam {Object} selfCourse  私教课（当课程类型为2的时候，必传）
 * @apiParam {String} selfCourse.courseName  私教课名称
 * @apiParam {String} selfCourse.storeName  私教课门店信息
 * @apiParam {String} selfCourse.description  私教课描述
 * @apiParam {Number} selfCourse.isSend  是否推送
 * @apiParam {Object} selfCourse.addressInfo  地址信息
 * @apiParam {string} selfCourse.addressInfo.provinceId  省Id
 * @apiParam {string} selfCourse.addressInfo.cityId  城市Id
 * @apiParam {string} selfCourse.addressInfo.areaId  区域Id
 * @apiParam {string} selfCourse.addressInfo.lat  维度
 * @apiParam {string} selfCourse.addressInfo.lon
 * @apiParam {Array} selfCourse.images  私教课图片信息
 * @apiParam {Object} camp  训练营（当课程类型为3时，必传）
 * @apiParam {String} camp.courseName  课程名称
 * @apiParam {Number} camp.peopleNum  训练营总人数
 * @apiParam {Number} camp.label  标签
 * @apiParam {String} camp.description  训练营描述
 * @apiParam {Array} camp.images  训练营相关图片介绍
 * @apiParam {Object} camp.addressInfo  地址信息
 * @apiParam {string} camp.addressInfo.provinceId  省Id
 * @apiParam {string} camp.addressInfo.cityId  城市Id
 * @apiParam {string} camp.addressInfo.lat  维度
 * @apiParam {string} camp.addressInfo.areaId  区域Id
 * @apiParam {string} camp.addressInfo.lon
 *
 *
 * @apiExample Example usage:
 * curl -i http://localhost:3502/v1/course/modify
 *
 * @apiSuccess {Number} code      请求结果编码，0：正常， 其他为异常
 * @apiSuccess {string} message    请求结果编码对应的message
 *
 * @apiSuccessExample 正常响应：
 *     HTTP/1.1 200
 {
    "code": 200,
    "message": "请求成功"
}
 *
 *
 * @apiError  ServerError  服务器异常
 *
 * @apiErrorExample Response (example):
 *     HTTP/1.1 500 ServerError
 *     {
 *       "code": 500,
 *       "message": "服务器异常"
 *     }
 */
router.post('/modify', verifyUser.verify(), joiValidate(joi.object().keys({
  courseId: joi.number().required().label('请选择要修改的课程'),
  bigCourse: joi.when('type', { is: 1, then: joi.object({
          courseName: joi.string().label('请传入团课名称'),
          classTime: joi.number().label('请传入课时时间（分钟）'),
          peopleNum: joi.number().label('请传入参加总人数'),
          storeName: joi.string().label('请传入门店名称'),
          label: joi.string().label('请传入标签名称'),
          description: joi.string().label('请传入描述信息'),
          startTime: joi.string().label('请选择开始时间'),
          signEndTime: joi.string().label('请选择开始时间'),
          images: joi.array().items(joi.string()).label('请传入图片介绍'),
          addressInfo: joi.object({
            provinceId: joi.string().label('请传入省市Id'),
            cityId: joi.string().label('请传入城市Id'),
            lat: joi.string().label('请传入维度'),
            lon: joi.string().label('请传入精度'),
            areaId: joi.string().label('请传入区域Id'),
          })
      }).label('请完善团课信息')}),
  selfCourse: joi.when('type', { is: 2, then: joi.object({
          courseName: joi.string().label('请传入私教课标题'),
          storeName: joi.string().label('请传入门店信息'),
          description: joi.string().label('请传入描述信息'),
          isSend: joi.number().valid([0, 1]).label('是否推送'),
          images: joi.array().items(joi.string()).min(1).label('请传入图片介绍'),
          details: joi.array().items(joi.object({
            campId: joi.number().label('请传入课时Id'),
            className: joi.string().required().label('请传入课时名称'),
            storeName: joi.string().required().label('请传入课时位置'),
            classStartTime: joi.string().isoDate().required().label('请传入开课时间')
          })).label('请完善课时的相关信息'),
          addressInfo: joi.object({
            provinceId: joi.string().label('请传入省市Id'),
            cityId: joi.string().label('请传入城市Id'),
            lat: joi.string().label('请传入维度'),
            lon: joi.string().label('请传入精度'),
            areaId: joi.string().label('请传入区域Id'),
          })
      }).label('请完善私教信息')}),
  camp: joi.when('type', { is: 3, then: joi.object({
          courseName: joi.string().label('请传入训练营课标题'),
          peopleNum: joi.number().label('请传入训练营总人数'),
          description: joi.string().label('请传入描述信息'),
          label: joi.string().label('请传入标签名称'),
          images: joi.array().items(joi.string()).label('请传入图片介绍'),
          signEndTime: joi.string().label('请选择开始时间'),
          details: joi.array().items(joi.object({
            campId: joi.number().label('请传入课时Id'),
            className: joi.string().required().label('请传入课时名称'),
            storeName: joi.string().required().label('请传入课时位置'),
            classStartTime: joi.string().isoDate().required().label('请传入开课时间')
          })).label('请完善课时的相关信息'),
          addressInfo: joi.object({
            provinceId: joi.string().label('请传入省市Id'),
            cityId: joi.string().label('请传入城市Id'),
            lat: joi.string().label('请传入维度'),
            lon: joi.string().label('请传入精度'),
            areaId: joi.string().label('请传入区域Id'),
          })
      }).label('请完善私教相关信息') })
})), (req, res, next) => {
  const { courseId, bigCourse, selfCourse, camp } = req.body;
  const { userId } = req.user;
  courseService.modify({ courseId, userId, bigCourse, selfCourse, camp })
    .then(data => res.success(data))
    .catch(e => next(e))
});

/**
 * @api {post} /v1/course/camp/modify  课时修改信息
 * @apiVersion 1.0.0
 * @apiName CourseCampModify
 * @apiGroup  Course
 *
 * @apiDescription 课时修改信息
 * @apiParam {Number} campId  课时Id
 * @apiParam {String} className  课时名称
 * @apiParam {String} storeName  地址
 * @apiParam {String} classStartTime 开始时间
 *
 *
 * @apiExample Example usage:
 * curl -i http://localhost:3502/v1/course/modify
 *
 * @apiSuccess {Number} code      请求结果编码，0：正常， 其他为异常
 * @apiSuccess {string} message    请求结果编码对应的message
 *
 * @apiSuccessExample 正常响应：
 *     HTTP/1.1 200
 {
    "code": 200,
    "message": "请求成功"
}
 *
 *
 * @apiError  ServerError  服务器异常
 *
 * @apiErrorExample Response (example):
 *     HTTP/1.1 500 ServerError
 *     {
 *       "code": 500,
 *       "message": "服务器异常"
 *     }
 */
router.post('/camp/modify', verifyUser.verify(), joiValidate(joi.object().keys({
    campId: joi.number().required().label('请传入课时Id'),
    className: joi.string().label('请传入课时名称'),
    storeName: joi.string().label('请传入课时位置'),
    classStartTime: joi.string().isoDate().label('请传入开课时间')
})), (req, res, next) => {
    const { campId, className, storeName, classStartTime } = req.body;
    const { userId } = req.user;
    courseService.modifyCamp({ userId, campId, className, storeName, classStartTime })
        .then(data => res.success(data))
        .catch(e => next(e))
})

/**
 * @api {post} /v1/course/remove  删除课程
 * @apiVersion 1.0.0
 * @apiName CourseRemove
 * @apiGroup  Course
 *
 * @apiDescription 删除课程
 *
 * @apiParam {Number} courseId  课程Id
 *
 *
 * @apiExample Example usage:
 * curl -i http://localhost:3502/v1/course/remove
 *
 * @apiSuccess {Number} code      请求结果编码，0：正常， 其他为异常
 * @apiSuccess {string} message    请求结果编码对应的message
 *
 * @apiSuccessExample 正常响应：
 *     HTTP/1.1 200
 {
    "code": 200,
    "message": "请求成功"
}
 *
 *
 * @apiError  ServerError  服务器异常
 *
 * @apiErrorExample Response (example):
 *     HTTP/1.1 500 ServerError
 *     {
 *       "code": 500,
 *       "message": "服务器异常"
 *     }
 */
router.post('/remove', verifyUser.verify(), joiValidate(joi.object().keys({
    courseId: joi.number().required().label('请选择要修改的课程')
})), (req, res, next) => {
    const { courseId } = req.body;
    const { userId } = req.user;
    courseService.remove({ courseId, userId })
        .then(data => res.success(data))
        .catch(e => next(e))
});

/**
 * @api {post} /v1/course/active  激活课程(只针对私教)
 * @apiVersion 1.0.0
 * @apiName CourseActive
 * @apiGroup  Course
 *
 * @apiDescription 激活课程
 *
 * @apiParam {Number} courseId  课程Id
 *
 *
 * @apiExample Example usage:
 * curl -i http://localhost:3502/v1/course/active
 *
 * @apiSuccess {Number} code      请求结果编码，0：正常， 其他为异常
 * @apiSuccess {string} message    请求结果编码对应的message
 *
 * @apiSuccessExample 正常响应：
 *     HTTP/1.1 200
 {
    "code": 200,
    "message": "请求成功"
}
 *
 *
 * @apiError  ServerError  服务器异常
 *
 * @apiErrorExample Response (example):
 *     HTTP/1.1 500 ServerError
 *     {
 *       "code": 500,
 *       "message": "服务器异常"
 *     }
 */
router.post('/active', verifyUser.verify(), joiValidate(joi.object().keys({
  courseId: joi.number().required().label('请选择要激活的课程')
})), (req, res, next) => {
  const { courseId } = req.body;
  const { userId } = req.user;
  courseService.active({ courseId, userId })
    .then(data => res.success(data))
    .catch(e => next(e))
});

/**
 * @api {post} /v1/course/report  举报课程
 * @apiVersion 1.0.0
 * @apiName CourseReport
 * @apiGroup  Course
 *
 * @apiDescription 举报课程
 *
 * @apiParam {Number} courseId  课程Id
 * @apiParam {Array} kind  举报类型(["1", "2", "3", "4"])
 * @apiParam {String} [reason]  举报理由
 *
 *
 * @apiExample Example usage:
 * curl -i http://localhost:3502/v1/course/report
 *
 * @apiSuccess {Number} code      请求结果编码，0：正常， 其他为异常
 * @apiSuccess {string} message    请求结果编码对应的message
 *
 * @apiSuccessExample 正常响应：
 *     HTTP/1.1 200
 {
    "code": 200,
    "message": "请求成功"
}
 *
 *
 * @apiError  ServerError  服务器异常
 *
 * @apiErrorExample Response (example):
 *     HTTP/1.1 500 ServerError
 *     {
 *       "code": 500,
 *       "message": "服务器异常"
 *     }
 */
router.post('/report', verifyUser.verify(), joiValidate(joi.object().keys({
  courseId: joi.number().required().label('请选择要举报的课程'),
  kind: joi.array().items(joi.string()).required().label('请选择举报理由'),
  reason: joi.string().label('请填入其他理由')
})), (req, res, next) => {
  const { courseId, kind, reason } = req.body;
  const { userId } = req.user;

  courseService.report({ courseId, kind, reason, userId })
    .then(() => res.success())
    .catch(e => next(e))
});

/**
 * @api {get} /v1/course/report/list 获取用户的投诉列表
 * @apiVersion 1.0.0
 * @apiName getCourseTicket
 * @apiGroup  Course
 *
 * @apiDescription 获取申述列表
 *
 * @apiParam {number} [offset] 分页参数
 * @apiParam {number} [limit] 分页参数
 *
 * @apiExample Example usage:
 * curl -d http://localhost:3501/v1/course/report/list
 *
 * @apiSuccess {Number} code      请求结果编码，0：正常， 其他为异常
 * @apiSuccess {string} message    请求结果编码对应的message
 * @apiSuccess {Object} data    请求结果集
 * @apiSuccess {Object} data.list    请求结果集
 * @apiSuccess {Number} data.list.courseId    课程Id
 * @apiSuccess {Number} data.list.jUserId    用户Id
 * @apiSuccess {String} data.list.refuseReason    拒绝理由
 * @apiSuccess {String} data.list.reportReason    举报理由
 * @apiSuccess {Number} data.list.status    (1代表同意，0代表初始状态未处理，-1代表驳回)
 * @apiSuccess {String} data.list.createTime    开始时间
 * @apiSuccess {String} data.list.userName    用户昵称
 * @apiSuccess {Number} data.list.userId    用户Id
 * @apiSuccess {String} data.list.courseName    课程名称
 * @apiSuccess {Array} data.list.reportKind    举报种类
 * @apiSuccess {Number} data.count    数量
 *
 * @apiSuccessExample 正常响应：
 *     HTTP/1.1 200
 {
    "code": 200,
    "message": "请求成功",
    "data": {
        "list": [
            {
                "courseId": 1,
                "jUserId": 1,
                "reason": "aafsdfdasf",
                "status": 1,
                "createTime": "2019-07-08 14:42:54",
                "userName": "文坦",
                "userId": 1,
                "courseName": "修改团课"
            }
        ],
        "count": 1
    }
}
 *
 *
 * @apiError  ServerError  服务器异常
 *
 * @apiErrorExample Response (example):
 *     HTTP/1.1 500 ServerError
 *     {
 *       "code": 500,
 *       "message": "服务器异常"
 *     }
 */
router.get('/report/list', verifyUser.verify(), joiValidate(joi.object().keys({
    offset: joi.number().label('请传入分页参数'),
    limit: joi.number().label('请传入分页参数'),
})), (req, res, next) => {
    let { limit, offset } = req.query;
    offset = offset && Number(offset) || 0;
    limit = limit && Number(limit) || 20;
    const { userId } = req.user;
    courseService.reportList({ limit, offset, userId })
        .then((data) => res.success(data))
        .catch(e => next(e))
});

/**
 * @api {post} /v1/course/cancel  教练取消课程
 * @apiVersion 1.0.0
 * @apiName UserCourseCancel
 * @apiGroup  User
 *
 * @apiDescription 教练取消课程
 *
 * @apiParam {number} courseId 课程Id
 *
 * @apiExample Example usage:
 * curl -i http://localhost:3502/v1/course/cancel
 *
 * @apiSuccess {Number} code      请求结果编码，0：正常， 其他为异常
 * @apiSuccess {string} message    请求结果编码对应的message
 *
 * @apiSuccessExample 正常响应：
 *     HTTP/1.1 200
 *     {
          "code": 200,
          "message": "请求成功"
       }
 *
 *
 * @apiError  ServerError  服务器异常
 *
 * @apiErrorExample Response (example):
 *     HTTP/1.1 500 ServerError
 *     {
 *       "code": 500,
 *       "message": "服务器异常"
 *     }
 */
router.post('/cancel', verifyUser.verify(), joiValidate(joi.object().keys({
  courseId: joi.number().required().label('请传入课程Id')
})), (req, res, next) => {
  const { courseId } = req.body;
  const { userId } = req.user;
  courseService.cancel({ courseId, userId })
    .then(() => res.success())
    .catch(e => next(e))
});

module.exports = router;
